package com.zouxw.utils.json.controller;

import com.zouxw.utils.json.model.JsonModel;
import com.zouxw.utils.json.model.JsonNode;
import com.zouxw.utils.json.utils.JsonParseException;
import com.zouxw.utils.json.utils.ExceptionHandler;
import com.zouxw.utils.json.utils.DebounceUtil;
import com.zouxw.utils.json.utils.HistoryManager;
import com.zouxw.utils.json.utils.TreeExpansionStateManager;
import com.zouxw.utils.json.view.JsonTreeView;

import javax.swing.*;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import java.awt.Component;
import java.util.Observable;
import java.util.Observer;

/**
 * JSON主控制器
 * 负责协调Model和View之间的交互，处理用户操作
 * 
 * @author zouxw
 * @version 1.0
 */
public class JsonController implements Observer {
    
    // ==================== 组件引用 ====================
    /** JSON数据模型 */
    private JsonModel jsonModel;
    
    /** JSON树形视图 */
    private JsonTreeView jsonTreeView;
    
    /** 主窗口组件（用于显示对话框） */
    private Component parentComponent;
    
    /** 防抖执行器 - JSON验证 */
    private DebounceUtil.DebounceExecutorWithParam<String> validationDebouncer;
    
    /** 防抖执行器 - 搜索 */
    private DebounceUtil.DebounceExecutorWithParam<String> searchDebouncer;
    
    /** 历史管理器 */
    private HistoryManager historyManager;
    
    /** 树展开状态管理器 */
    private TreeExpansionStateManager expansionStateManager;
    
    // ==================== 构造函数 ====================
    
    /**
     * 构造函数
     * 
     * @param parentComponent 父组件
     */
    public JsonController(Component parentComponent) {
        this.parentComponent = parentComponent;
        this.jsonModel = new JsonModel();
        this.jsonModel.addObserver(this);
        this.historyManager = new HistoryManager();
        this.expansionStateManager = new TreeExpansionStateManager();
        
        // 初始化防抖执行器
        initializeDebouncers();
    }
    
    // ==================== 初始化方法 ====================
    
    /**
     * 初始化防抖执行器
     */
    private void initializeDebouncers() {
        // JSON验证防抖 - 300ms延迟
        validationDebouncer = DebounceUtil.create(300, this::performValidation);
        
        // 搜索防抖 - 200ms延迟
        searchDebouncer = DebounceUtil.create(200, this::performSearch);
    }
    
    /**
     * 初始化控制器
     * 
     * @param jsonTreeView JSON树形视图
     */
    public void initialize(JsonTreeView jsonTreeView) {
        this.jsonTreeView = jsonTreeView;
        setupViewListeners();
    }
    
    /**
     * 设置视图监听器
     */
    private void setupViewListeners() {
        if (jsonTreeView == null) return;
        
        // 设置双击监听器
        jsonTreeView.setDoubleClickListener((node, path) -> handleNodeDoubleClick(node, path));
        
        // 设置右键菜单监听器
        jsonTreeView.setPopupMenuListener(new JsonTreeView.TreePopupMenuListener() {
            @Override
            public void onPopupMenuRequested(JsonNode node, TreePath path, int x, int y) {
                handlePopupMenuRequested(node, path, x, y);
            }
            
            @Override
            public void onAddPropertyRequested(JsonNode node, TreePath path) {
                handleAddPropertyRequested(node, path);
            }
            
            @Override
            public void onAddArrayItemRequested(JsonNode node, TreePath path) {
                handleAddArrayItemRequested(node, path);
            }
            
            @Override
            public void onDeleteRequested(JsonNode node, TreePath path) {
                handleDeleteRequested(node, path);
            }
        });
        
        // 设置选择变化监听器
        jsonTreeView.setSelectionListener((node, path) -> handleSelectionChanged(node, path));
    }
    
    // ==================== 公共方法 ====================
    
    /**
     * 解析JSON字符串
     * 
     * @param jsonString JSON字符串
     */
    public void parseJson(String jsonString) {
        try {
            System.out.println("JsonController: 开始解析JSON");
            jsonModel.parseJson(jsonString);
            System.out.println("JsonController: JSON解析成功");
            
            // 保存到历史记录
            historyManager.saveState(jsonString, "解析JSON");
        } catch (JsonParseException e) {
            System.out.println("JsonController: JSON解析失败: " + e.getMessage());
            ExceptionHandler.handleJsonParseError(parentComponent, e);
        }
    }
    
    /**
     * 验证JSON字符串（带防抖）
     * 
     * @param jsonString JSON字符串
     * @return 验证状态
     */
    public JsonModel.ValidationStatus validateJson(String jsonString) {
        return jsonModel.validateJson(jsonString);
    }
    
    /**
     * 防抖验证JSON字符串
     * 
     * @param jsonString JSON字符串
     */
    public void validateJsonDebounced(String jsonString) {
        validationDebouncer.execute(jsonString);
    }
    
    /**
     * 执行验证（防抖回调）
     * 
     * @param jsonString JSON字符串
     */
    private void performValidation(String jsonString) {
        JsonModel.ValidationStatus status = jsonModel.validateJson(jsonString);
        // 这里可以通知UI更新状态
    }
    
    /**
     * 格式化JSON
     * 
     * @param pretty 是否美化格式
     */
    public void formatJson(boolean pretty) {
        try {
            jsonModel.formatJson(pretty);
        } catch (JsonParseException e) {
            ExceptionHandler.handleJsonParseError(parentComponent, e);
        }
    }
    
    /**
     * 搜索节点
     * 
     * @param searchText 搜索文本
     * @return 是否找到匹配项
     */
    public boolean searchNodes(String searchText) {
        if (jsonTreeView == null) return false;
        return jsonTreeView.searchAndHighlight(searchText);
    }
    
    /**
     * 防抖搜索节点
     * 
     * @param searchText 搜索文本
     */
    public void searchNodesDebounced(String searchText) {
        searchDebouncer.execute(searchText);
    }
    
    /**
     * 执行搜索（防抖回调）
     * 
     * @param searchText 搜索文本
     */
    private void performSearch(String searchText) {
        if (jsonTreeView != null) {
            jsonTreeView.searchAndHighlight(searchText);
        }
    }
    
    /**
     * 清除搜索高亮
     */
    public void clearSearch() {
        if (jsonTreeView != null) {
            jsonTreeView.clearHighlight();
        }
    }
    
    // ==================== 历史管理方法 ====================
    
    /**
     * 撤销操作
     * 
     * @return 撤销后的JSON内容，如果没有可撤销的操作返回null
     */
    public String undo() {
        HistoryManager.HistoryState state = historyManager.undo();
        if (state != null) {
            try {
                jsonModel.parseJson(state.getJsonContent());
                return state.getJsonContent();
            } catch (JsonParseException e) {
                ExceptionHandler.handleJsonParseError(parentComponent, e);
            }
        }
        return null;
    }
    
    /**
     * 重做操作
     * 
     * @return 重做后的JSON内容，如果没有可重做的操作返回null
     */
    public String redo() {
        HistoryManager.HistoryState state = historyManager.redo();
        if (state != null) {
            try {
                jsonModel.parseJson(state.getJsonContent());
                return state.getJsonContent();
            } catch (JsonParseException e) {
                ExceptionHandler.handleJsonParseError(parentComponent, e);
            }
        }
        return null;
    }
    
    /**
     * 检查是否可以撤销
     * 
     * @return 是否可以撤销
     */
    public boolean canUndo() {
        return historyManager.canUndo();
    }
    
    /**
     * 检查是否可以重做
     * 
     * @return 是否可以重做
     */
    public boolean canRedo() {
        return historyManager.canRedo();
    }
    
    /**
     * 获取撤销操作描述
     * 
     * @return 撤销操作描述
     */
    public String getUndoDescription() {
        return historyManager.getUndoDescription();
    }
    
    /**
     * 获取重做操作描述
     * 
     * @return 重做操作描述
     */
    public String getRedoDescription() {
        return historyManager.getRedoDescription();
    }
    
    /**
     * 清空历史记录
     */
    public void clearHistory() {
        historyManager.clear();
    }
    
    /**
     * 展开所有节点
     */
    public void expandAllNodes() {
        if (jsonTreeView != null) {
            jsonTreeView.expandAllNodes();
        }
    }
    
    /**
     * 折叠所有节点
     */
    public void collapseAllNodes() {
        if (jsonTreeView != null) {
            jsonTreeView.collapseAllNodes();
        }
    }
    
    /**
     * 获取当前JSON字符串
     * 
     * @return 当前JSON字符串
     */
    public String getCurrentJsonString() {
        return jsonModel.getCurrentJsonString();
    }
    
    /**
     * 获取验证状态
     * 
     * @return 验证状态
     */
    public JsonModel.ValidationStatus getValidationStatus() {
        return jsonModel.getValidationStatus();
    }
    
    /**
     * 获取验证错误消息
     * 
     * @return 验证错误消息
     */
    public String getValidationErrorMessage() {
        return jsonModel.getValidationErrorMessage();
    }
    
    /**
     * 是否已修改
     * 
     * @return 是否已修改
     */
    public boolean isModified() {
        return jsonModel.isModified();
    }
    
    /**
     * 重置模型
     */
    public void reset() {
        jsonModel.reset();
    }
    
    // ==================== 事件处理方法 ====================
    
    /**
     * 处理节点双击事件
     * 
     * @param node 节点
     * @param path 路径
     */
    private void handleNodeDoubleClick(JsonNode node, TreePath path) {
        if (!node.isEditable()) {
            ExceptionHandler.showInfo(parentComponent, "信息", "该节点不可编辑");
            return;
        }
        
        try {
            Object newValue = showEditDialog(node);
            if (newValue != null) {
                // 更新节点值
                updateNodeValue(node, path, newValue);
            }
        } catch (Exception e) {
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }
    
    /**
     * 处理右键菜单请求
     * 
     * @param node 节点
     * @param path 路径
     * @param x X坐标
     * @param y Y坐标
     */
    private void handlePopupMenuRequested(JsonNode node, TreePath path, int x, int y) {
        // 根据节点类型启用/禁用菜单项
        updatePopupMenuState(node);
    }
    
    /**
     * 处理添加属性请求
     * 
     * @param node 节点
     * @param path 路径
     */
    private void handleAddPropertyRequested(JsonNode node, TreePath path) {
        if (!node.isObject()) {
            ExceptionHandler.showWarning(parentComponent, "警告", "只能在对象节点上添加属性");
            return;
        }
        
        try {
            String key = JOptionPane.showInputDialog(parentComponent, "请输入属性名:", "添加属性", JOptionPane.QUESTION_MESSAGE);
            if (key == null || key.trim().isEmpty()) {
                return;
            }
            
            String value = JOptionPane.showInputDialog(parentComponent, "请输入属性值:", "添加属性", JOptionPane.QUESTION_MESSAGE);
            if (value == null) {
                return;
            }
            
            // 这里需要实现属性添加逻辑
            ExceptionHandler.showInfo(parentComponent, "信息", "属性已添加: " + key);
            
        } catch (Exception e) {
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }
    
    /**
     * 处理添加数组元素请求
     * 
     * @param node 节点
     * @param path 路径
     */
    private void handleAddArrayItemRequested(JsonNode node, TreePath path) {
        if (!node.isArray()) {
            ExceptionHandler.showWarning(parentComponent, "警告", "只能在数组节点上添加元素");
            return;
        }
        
        try {
            String value = JOptionPane.showInputDialog(parentComponent, "请输入数组元素值:", "添加数组元素", JOptionPane.QUESTION_MESSAGE);
            if (value == null) {
                return;
            }
            
            // 这里需要实现数组元素添加逻辑
            ExceptionHandler.showInfo(parentComponent, "信息", "数组元素已添加");
            
        } catch (Exception e) {
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }
    
    /**
     * 处理删除请求
     * 
     * @param node 节点
     * @param path 路径
     */
    private void handleDeleteRequested(JsonNode node, TreePath path) {
        if (node.isRoot()) {
            ExceptionHandler.showWarning(parentComponent, "警告", "不能删除根节点");
            return;
        }
        
        int result = JOptionPane.showConfirmDialog(parentComponent,
                "确定要删除选中的节点吗?",
                "确认删除",
                JOptionPane.YES_NO_OPTION);
        
        if (result == JOptionPane.YES_OPTION) {
            try {
                // 这里需要实现节点删除逻辑
                ExceptionHandler.showInfo(parentComponent, "信息", "节点已删除");
                
            } catch (Exception e) {
                ExceptionHandler.handleGenericError(parentComponent, e);
            }
        }
    }
    
    /**
     * 处理选择变化
     * 
     * @param node 节点
     * @param path 路径
     */
    private void handleSelectionChanged(JsonNode node, TreePath path) {
        // 可以在这里更新状态栏或其他UI组件
        // 暂时不实现具体逻辑
    }
    
    // ==================== 观察者模式实现 ====================
    
    /**
     * 模型更新通知
     * 
     * @param o 观察者
     * @param arg 参数
     */
    @Override
    public void update(Observable o, Object arg) {
        if (o == jsonModel) {
            System.out.println("JsonController: 收到模型更新通知");
            updateViewFromModel();
        }
    }
    
    /**
     * 从模型更新视图
     */
    private void updateViewFromModel() {
        if (jsonTreeView == null) {
            System.out.println("JsonController: jsonTreeView为null，无法更新视图");
            return;
        }
        
        try {
            System.out.println("JsonController: 开始更新视图");
            // 根据模型状态更新视图
            if (jsonModel.getRootJsonObject() != null) {
                System.out.println("JsonController: 构建树模型");
                // 构建树模型
                DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode("JSON Root");
                buildTreeFromModel(rootNode, jsonModel.getRootJsonObject(), "");
                
                DefaultTreeModel treeModel = new DefaultTreeModel(rootNode);
                jsonTreeView.setTreeModel(treeModel);
                System.out.println("JsonController: 树模型设置完成");
                
                // 展开所有节点
                jsonTreeView.expandAllNodes();
            } else {
                System.out.println("JsonController: 清空树模型");
                // 清空树
                jsonTreeView.setTreeModel(new DefaultTreeModel(new DefaultMutableTreeNode("JSON Root")));
            }
            
        } catch (Exception e) {
            System.err.println("更新视图时出错: " + e.getMessage());
            e.printStackTrace();
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }
    
    /**
     * 更新节点值并刷新树
     * 
     * @param node 节点
     * @param path 路径
     * @param newValue 新值
     */
    private void updateNodeValue(JsonNode node, TreePath path, Object newValue) {
        try {
            // 保存当前展开状态
            if (jsonTreeView != null) {
                expansionStateManager.saveExpansionState(jsonTreeView.getTree());
            }

            // 更新节点显示文本
            String displayText = node.toString();
            if (displayText.contains(": ")) {
                // 如果是键值对形式，保留键部分
                String key = displayText.substring(0, displayText.indexOf(": "));
                node.setUserObject(key + ": " + newValue.toString());
            } else {
                // 如果是纯值，直接更新
                node.setUserObject(newValue.toString());
            }

            // 更新节点的原始值
            node.setJsonValue(newValue);

            // 更新JSON数据结构
            updateJsonStructure(node, path, newValue);

            // 刷新树显示
            if (jsonTreeView != null) {
                jsonTreeView.refreshTree();
                
                // 恢复展开状态
                expansionStateManager.restoreExpansionState(jsonTreeView.getTree());
            }

            // 更新JSON文本区域
            updateJsonTextArea();

            // 保存到历史记录
            historyManager.saveState(getCurrentJsonString(), "编辑节点值");

            System.out.println("节点值已更新: " + newValue);
        } catch (Exception e) {
            System.err.println("更新节点值时出错: " + e.getMessage());
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }

    /**
     * 更新JSON数据结构
     * 
     * @param node 节点
     * @param path 路径
     * @param newValue 新值
     */
    private void updateJsonStructure(JsonNode node, TreePath path, Object newValue) {
        try {
            // 获取节点的路径
            Object[] pathArray = path.getPath();

            // 从根节点开始遍历路径
            Object current = jsonModel.getRootJsonObject();
            for (int i = 1; i < pathArray.length - 1; i++) {
                JsonNode pathNode = (JsonNode) pathArray[i];
                String nodeName = pathNode.toString();

                if (current instanceof com.alibaba.fastjson.JSONObject) {
                    com.alibaba.fastjson.JSONObject obj = (com.alibaba.fastjson.JSONObject) current;

                    // 检查节点名是否是键
                    if (obj.containsKey(nodeName)) {
                        current = obj.get(nodeName);
                    } else {
                        // 可能是数组索引
                        try {
                            int index = Integer.parseInt(nodeName.replace("[", "").replace("]", ""));
                            if (current instanceof com.alibaba.fastjson.JSONArray) {
                                com.alibaba.fastjson.JSONArray arr = (com.alibaba.fastjson.JSONArray) current;
                                if (index >= 0 && index < arr.size()) {
                                    current = arr.get(index);
                                }
                            }
                        } catch (NumberFormatException e) {
                            // 不是数组索引，继续处理
                        }
                    }
                } else if (current instanceof com.alibaba.fastjson.JSONArray) {
                    com.alibaba.fastjson.JSONArray arr = (com.alibaba.fastjson.JSONArray) current;
                    try {
                        int index = Integer.parseInt(nodeName.replace("[", "").replace("]", ""));
                        if (index >= 0 && index < arr.size()) {
                            current = arr.get(index);
                        }
                    } catch (NumberFormatException e) {
                        // 不是数组索引，忽略
                    }
                }
            }

            // 更新值
            String nodeName = node.toString();
            if (nodeName.contains(": ")) {
                nodeName = nodeName.substring(0, nodeName.indexOf(": "));
            }

            if (current instanceof com.alibaba.fastjson.JSONObject) {
                com.alibaba.fastjson.JSONObject obj = (com.alibaba.fastjson.JSONObject) current;
                obj.put(nodeName, newValue);
            } else if (current instanceof com.alibaba.fastjson.JSONArray) {
                com.alibaba.fastjson.JSONArray arr = (com.alibaba.fastjson.JSONArray) current;
                try {
                    int index = Integer.parseInt(nodeName.replace("[", "").replace("]", ""));
                    if (index >= 0 && index < arr.size()) {
                        arr.set(index, newValue);
                    }
                } catch (NumberFormatException e) {
                    // 不是数组索引，忽略
                }
            }
        } catch (Exception e) {
            System.err.println("更新JSON结构时出错: " + e.getMessage());
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }

    /**
     * 更新JSON文本区域
     */
    private void updateJsonTextArea() {
        try {
            String formattedJson = com.alibaba.fastjson.JSON.toJSONString(jsonModel.getRootJsonObject(), true);
            // 通知主界面更新文本区域
            if (parentComponent instanceof com.zouxw.utils.json.EnhancedJsonTreeViewerV2) {
                ((com.zouxw.utils.json.EnhancedJsonTreeViewerV2) parentComponent).updateJsonInputArea(formattedJson);
            }
        } catch (Exception e) {
            System.err.println("更新JSON文本时出错: " + e.getMessage());
            ExceptionHandler.handleGenericError(parentComponent, e);
        }
    }


    // ==================== 私有辅助方法 ====================
    
    /**
     * 显示编辑对话框
     * 
     * @param node 节点
     * @return 新值
     */
    private Object showEditDialog(JsonNode node) {
        String currentValue = node.toString();
        String valueType = node.getValueType();
        
        if (JsonNode.VALUE_TYPE_STRING.equals(valueType) || JsonNode.VALUE_TYPE_NESTED_JSON.equals(valueType)) {
            // 字符串类型 - 使用文本区域编辑
            JTextArea textArea = new JTextArea(currentValue, 10, 30);
            textArea.setLineWrap(true);
            textArea.setWrapStyleWord(true);
            
            int result = JOptionPane.showConfirmDialog(parentComponent,
                    new JScrollPane(textArea),
                    "编辑值",
                    JOptionPane.OK_CANCEL_OPTION,
                    JOptionPane.PLAIN_MESSAGE);
            
            if (result == JOptionPane.OK_OPTION) {
                return textArea.getText();
            }
        } else if (JsonNode.VALUE_TYPE_NUMBER.equals(valueType)) {
            // 数字类型 - 使用文本字段编辑
            String input = JOptionPane.showInputDialog(parentComponent,
                    "编辑数值:",
                    currentValue);
            
            if (input != null) {
                try {
                    if (input.contains(".")) {
                        return Double.parseDouble(input);
                    } else {
                        return Long.parseLong(input);
                    }
                } catch (NumberFormatException e) {
                    ExceptionHandler.handleNumberFormatError(parentComponent, e, input);
                    return null;
                }
            }
        } else if (JsonNode.VALUE_TYPE_BOOLEAN.equals(valueType)) {
            // 布尔类型 - 使用选项对话框
            Object[] options = {"true", "false"};
            int result = JOptionPane.showOptionDialog(parentComponent,
                    "选择布尔值:",
                    "编辑布尔值",
                    JOptionPane.DEFAULT_OPTION,
                    JOptionPane.QUESTION_MESSAGE,
                    null,
                    options,
                    currentValue);
            
            if (result >= 0) {
                return Boolean.parseBoolean(options[result].toString());
            }
        } else if (JsonNode.VALUE_TYPE_NULL.equals(valueType)) {
            // null值 - 不能编辑
            ExceptionHandler.showInfo(parentComponent, "信息", "null值不能编辑");
            return null;
        } else {
            // 其他类型 - 使用文本字段编辑
            String input = JOptionPane.showInputDialog(parentComponent,
                    "编辑值:",
                    currentValue);
            
            if (input != null) {
                return input;
            }
        }
        
        return null;
    }
    
    /**
     * 更新右键菜单状态
     * 
     * @param node 节点
     */
    private void updatePopupMenuState(JsonNode node) {
        // 这里需要访问JsonTreeView的菜单项
        // 暂时简化实现
    }
    
    /**
     * 从模型构建树
     * 
     * @param parent 父节点
     * @param jsonValue JSON值
     * @param key 键名
     */
    private void buildTreeFromModel(DefaultMutableTreeNode parent, Object jsonValue, String key) {
        if (jsonValue == null) {
            JsonNode node = new JsonNode(key.isEmpty() ? "null" : key + ": null", null, JsonNode.VALUE_TYPE_NULL);
            parent.add(node);
            return;
        }
        
        String valueType = getValueType(jsonValue);
        
        if (valueType.equals(JsonNode.VALUE_TYPE_OBJECT)) {
            // 处理JSON对象
            com.alibaba.fastjson.JSONObject jsonObject = (com.alibaba.fastjson.JSONObject) jsonValue;
            String displayName = key.isEmpty() ? "Object" : key;
            JsonNode objectNode = new JsonNode(displayName, jsonValue, JsonNode.VALUE_TYPE_OBJECT);
            parent.add(objectNode);
            
            // 递归添加对象的属性
            for (String objKey : jsonObject.keySet()) {
                Object objValue = jsonObject.get(objKey);
                buildTreeFromModel(objectNode, objValue, objKey);
            }
            
        } else if (valueType.equals(JsonNode.VALUE_TYPE_ARRAY)) {
            // 处理JSON数组
            com.alibaba.fastjson.JSONArray jsonArray = (com.alibaba.fastjson.JSONArray) jsonValue;
            String displayName = key.isEmpty() ? "Array" : key;
            JsonNode arrayNode = new JsonNode(displayName + " [" + jsonArray.size() + "]", jsonValue, JsonNode.VALUE_TYPE_ARRAY);
            parent.add(arrayNode);
            
            // 递归添加数组元素
            for (int i = 0; i < jsonArray.size(); i++) {
                Object arrayValue = jsonArray.get(i);
                buildTreeFromModel(arrayNode, arrayValue, "[" + i + "]");
            }
            
        } else {
            // 处理基本类型（字符串、数字、布尔值等）
            String displayValue = formatValue(jsonValue);
            String displayName = key.isEmpty() ? displayValue : key + ": " + displayValue;
            
            // 检查是否是嵌套的JSON字符串
            if (valueType.equals(JsonNode.VALUE_TYPE_STRING) && isJsonString((String) jsonValue)) {
                // 创建可展开的字符串节点
                JsonNode stringNode = new JsonNode(displayName, jsonValue, JsonNode.VALUE_TYPE_STRING);
                parent.add(stringNode);
                
                // 尝试解析嵌套的JSON
                try {
                    Object nestedJson = com.alibaba.fastjson.JSON.parse((String) jsonValue);
                    buildTreeFromModel(stringNode, nestedJson, "解析内容");
                } catch (Exception e) {
                    // 如果解析失败，保持原样
                    System.out.println("嵌套JSON解析失败: " + e.getMessage());
                }
            } else {
                // 普通基本类型
                JsonNode node = new JsonNode(displayName, jsonValue, valueType);
                parent.add(node);
            }
        }
    }
    
    /**
     * 格式化值显示
     * 
     * @param value 值
     * @return 格式化后的字符串
     */
    private String formatValue(Object value) {
        if (value == null) return "null";
        if (value instanceof String) return "\"" + value + "\"";
        return value.toString();
    }
    
    /**
     * 检查字符串是否是有效的JSON
     * 
     * @param str 字符串
     * @return 是否是JSON
     */
    private boolean isJsonString(String str) {
        if (str == null || str.trim().isEmpty()) {
            return false;
        }
        
        String trimmed = str.trim();
        
        // 检查是否以 { 或 [ 开头
        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
            return false;
        }
        
        // 尝试解析JSON
        try {
            com.alibaba.fastjson.JSON.parse(trimmed);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * 获取值类型
     * 
     * @param value 值
     * @return 类型字符串
     */
    private String getValueType(Object value) {
        if (value instanceof com.alibaba.fastjson.JSONObject) return JsonNode.VALUE_TYPE_OBJECT;
        if (value instanceof com.alibaba.fastjson.JSONArray) return JsonNode.VALUE_TYPE_ARRAY;
        if (value instanceof String) return JsonNode.VALUE_TYPE_STRING;
        if (value instanceof Number) return JsonNode.VALUE_TYPE_NUMBER;
        if (value instanceof Boolean) return JsonNode.VALUE_TYPE_BOOLEAN;
        if (value == null) return JsonNode.VALUE_TYPE_NULL;
        return JsonNode.VALUE_TYPE_UNKNOWN;
    }
}
